﻿#include <iostream>
using namespace std;

//void Add(int x, int y)
//{
//	cout << "haha" << endl;
//}
//
//int Add(int a)
//{
//	return a + 10;
//}
//
//double Add(int x, double d)
//{
//	return x + d;
//}
//
//double Add(double d, int x)
//{
//	return x + d;
//}

//int main()
//{
//	int a = 10;
//	int& b = a;
//	cout << a << "--" << b << endl;
//	b++;
//	cout << a << "--" << b << endl;
//	cout << &a << endl;
//	cout << &b << endl;
//	return 0;
//}

//
//int main()
//{
//	int a = 10;
//	double& d = a;
//	return 0;
//}


//int main()
//{
//	int a = 3;
//	int& b = a; 
//	int& c = a;
//	int& d = c;
//	return 0;
//}


//int main()
//{
//	int x = 10;
//	int y = 20;
//	int& c = x;
//	cout << x << endl;
//	cout << c << endl;
//	c = y;//此处不是改变了引用实体，而是把y赋值给了c引用的实体
//	cout << c << endl;
//	cout << y << endl;
//	cout << &x << endl;
//	cout << &c << endl;
//	cout << &y << endl;
//	return 0;
//}

//int main()
//{
//	const int a = 10;//const 修饰的常变量具有常量的属性-->不可修改
//	const int& b = a;//权限放大了--->这里用非const 修饰的引用b去引用a，此时的b是可以修改的即放大了权限
//
//	int x = 10;
//	const int& y = x;//权限缩小
//	return 0;
//}


//int main()
//{
//	const int x = 100;
//	int c = x;//赋值
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	double d = 9.9;
//	int* pa = &a;
//	double* pd = &d;
//	(int*)(&d) = nullptr;//强转具有临时性和常形
//	return 0;
//}

//void Swap(int* x, int* y)
//{
//	int tmp = *x;
//	*x = *y;
//	*y = tmp;
//}
//
//void Swap(int& x, int& y)
//{
//	int tmp = x;
//	x = y;
//	y = tmp;
//}
//
//int main()
//{
//	int a = 3, b = 5;
//	printf("交换前: a = %d  b = %d\n", a, b);
//	Swap(a, b);
//	printf("交换后: a = %d  b = %d\n", a, b);
//	return 0;
//}

//typedef struct SLNode
//{
//	int data;
//	struct SLNode* next;
//}SLNode;
//
////头插
//void SLPushBack(SLNode** head)
//{
//
//}
//
//SLNode* head = NULL;
//SLPushBack(&head);



//typedef struct SLNode
//{
//	int data;
//	struct SLNode* next;
//}SLNode, *SLLink;
//
////头插
//void SLPushBack(SLNode*& head)
//{
//
//}
//
//SLLink head = NULL;
//SLPushBack(head);

//int& Count()
//{
//	static int n = 0;
//	n++;
//	return n;
//}


//int g_val = 0;
//int& Count(int n)
//{
//	g_val += n;
//	return g_val;
//}


//int& Add(int a, int b)
//{
//	int c = a + b;
//	return c;
//}
//
//int main()
//{
//	int& ret = Add(1, 2);
//	cout << "Add(1, 2) is :" << ret << endl;
//	Add(3, 4);
//	cout << "Add(1, 2) is :" << ret << endl;
//	return 0;
//}


//struct A 
//{
//	int a[100000];
//	char b;
//	double c;
//};
//
//void TestA1(struct A a1){}
//void TestA2(struct A& a2) {}
//
//int main()
//{
//	struct A a1;
//	size_t begin1 = clock();
//	for(int i = 0; i < 10000; i++)
//		TestA1(a1);
//	size_t end1 = clock();
//	cout << "传值消耗的时间： " << end1 - begin1 << endl;
//
//	size_t begin2 = clock();
//	for (int i = 0; i < 10000; i++)
//		TestA2(a1);
//	size_t end2 = clock();
//	cout << "传引用消耗的时间： " << end2 - begin2 << endl;
//
//	return 0;
//}



//struct A 
//{
//	int a[100000];
//	char b;
//	double c;
//};
//struct A a1;
//
//A TestA1() {
//	return a1;
//}
//A& TestA2() {
//	return a1;
//}
//
//int main()
//{
//	size_t begin1 = clock();
//	for(int i = 0; i < 10000; i++)
//		TestA1();
//	size_t end1 = clock();
//	cout << "值返回消耗的时间： " << end1 - begin1 << endl;
//
//	size_t begin2 = clock();
//	for (int i = 0; i < 10000; i++)
//		TestA2();
//	size_t end2 = clock();
//	cout << "引用返回消耗的时间： " << end2 - begin2 << endl;
//
//	return 0;
//}


//#include <time.h>
//struct A { int a[10000]; };
//A a;
//// 值返回
//A TestFunc1() { return a; }
//// 引用返回
//A& TestFunc2() { return a; }
//void TestReturnByRefOrValue()
//{
//	// 以值作为函数的返回值类型
//	size_t begin1 = clock();
//	for (size_t i = 0; i < 100000; ++i)
//		TestFunc1();
//	size_t end1 = clock();
//	// 以引用作为函数的返回值类型
//	size_t begin2 = clock();
//	for (size_t i = 0; i < 100000; ++i)
//		TestFunc2();
//	size_t end2 = clock();
//	// 计算两个函数运算完成之后的时间
//	cout << "TestFunc1 time:" << end1 - begin1 << endl;
//	cout << "TestFunc2 time:" << end2 - begin2 << endl;
//}
//
//int main()
//{
//	TestReturnByRefOrValue();
//	return 0;
//}


//int main()
//{
//	int a = 10;
//	int& b = a;
//	int* p = &a;
//	return 0;
//}

//inline int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int ret = Add(3, 5);
//	return 0;
//}


//inline int fun(int n)
//{
//	int x = 10;
//	int q = 100;
//	int w = 1;
//	int a = 3;
//	int z = 2;
//	int c = 21;
//	int v = 5;
//	int f = 6;
//	int g = 7;
//	int u = 9;
//	return x + 10;
//}

//extern inline int Add(int, int);
//int main()
//{
//	int ret = Add(3, 5);
//
//	return 0;
//}


//#define ADD(int x, int y) return x + y;
//#define ADD(x, y) return x + y;
//#define ADD(x, y) (x) + (y)

//#define ADD(x, y) x + y
//int main()
//{
//	int ret = ADD(2 | 1, 1 & 3); // 替换后--> 2 | 1 + 1 & 3
//	return 0;
//}

//
//#define ADD(x, y) ((x) + (y))
//int main()
//{
//	int ret = ADD(2,3) * 6; // 替换后--> (2) + (3) * 6;
//	return 0;
//}

//typedef char* pstring;
//int main()
//{
//	//const pstring p1;    // 编译成功还是失败？
//	const pstring* p2; 
//	return 0;
//}

//typedef char* pstring;
//int main()
//{
//	//const pstring p1;
//	const pstring* p2;
//	return 0;
//}
//
//#include <string>
//#include <map>
//
//typedef std::map<std::string, std::string> Map;
//int main()
//{
//	Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
//	return 0;
//}

//int main()
//{
//	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange",
//   "橙子" },{"pear","梨"} };
//	std::map<std::string, std::string>::iterator it = m.begin();
//
//	return 0;
//}


typedef char* pstring;
int main()
{
	const pstring p1 = NULL;
	const pstring* p2;
	return 0;
}